/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package entidade.controller.JPA;

import entidade.controller.JPA.exceptions.IllegalOrphanException;
import entidade.controller.JPA.exceptions.NonexistentEntityException;
import entidade.controller.JPA.exceptions.RollbackFailureException;
import entidade.persistencia.Usuario;
import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceUnit;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import entidade.persistencia.Empresa;
import entidade.persistencia.TipoUsuario;
import entidade.persistencia.Manutencao;
import java.util.ArrayList;
import java.util.List;
import entidade.persistencia.Compra;
import entidade.persistencia.Funcionario;
import entidade.persistencia.Venda;
import javax.transaction.UserTransaction;

/**
 *
 * @author victorinox
 */
public class UsuarioJpaController {
    @Resource
    private UserTransaction utx = null;
    @PersistenceUnit(unitName = "globalimage2PU")
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Usuario usuario) throws RollbackFailureException, Exception {
        if (usuario.getManutencaoCollection() == null) {
            usuario.setManutencaoCollection(new ArrayList<Manutencao>());
        }
        if (usuario.getCompraCollection() == null) {
            usuario.setCompraCollection(new ArrayList<Compra>());
        }
        if (usuario.getFuncionarioCollection() == null) {
            usuario.setFuncionarioCollection(new ArrayList<Funcionario>());
        }
        if (usuario.getVendaCollection() == null) {
            usuario.setVendaCollection(new ArrayList<Venda>());
        }
        if (usuario.getVendaCollection1() == null) {
            usuario.setVendaCollection1(new ArrayList<Venda>());
        }
        EntityManager em = null;
        try {
            utx.begin();
            em = getEntityManager();
            Empresa empresaId = usuario.getEmpresaId();
            if (empresaId != null) {
                empresaId = em.getReference(empresaId.getClass(), empresaId.getEmpresaId());
                usuario.setEmpresaId(empresaId);
            }
            TipoUsuario tipoUsuarioId = usuario.getTipoUsuarioId();
            if (tipoUsuarioId != null) {
                tipoUsuarioId = em.getReference(tipoUsuarioId.getClass(), tipoUsuarioId.getTipoUsuarioId());
                usuario.setTipoUsuarioId(tipoUsuarioId);
            }
            List<Manutencao> attachedManutencaoCollection = new ArrayList<Manutencao>();
            for (Manutencao manutencaoCollectionManutencaoToAttach : usuario.getManutencaoCollection()) {
                manutencaoCollectionManutencaoToAttach = em.getReference(manutencaoCollectionManutencaoToAttach.getClass(), manutencaoCollectionManutencaoToAttach.getManutencaoId());
                attachedManutencaoCollection.add(manutencaoCollectionManutencaoToAttach);
            }
            usuario.setManutencaoCollection(attachedManutencaoCollection);
            List<Compra> attachedCompraCollection = new ArrayList<Compra>();
            for (Compra compraCollectionCompraToAttach : usuario.getCompraCollection()) {
                compraCollectionCompraToAttach = em.getReference(compraCollectionCompraToAttach.getClass(), compraCollectionCompraToAttach.getCompraId());
                attachedCompraCollection.add(compraCollectionCompraToAttach);
            }
            usuario.setCompraCollection(attachedCompraCollection);
            List<Funcionario> attachedFuncionarioCollection = new ArrayList<Funcionario>();
            for (Funcionario funcionarioCollectionFuncionarioToAttach : usuario.getFuncionarioCollection()) {
                funcionarioCollectionFuncionarioToAttach = em.getReference(funcionarioCollectionFuncionarioToAttach.getClass(), funcionarioCollectionFuncionarioToAttach.getFuncionarioId());
                attachedFuncionarioCollection.add(funcionarioCollectionFuncionarioToAttach);
            }
            usuario.setFuncionarioCollection(attachedFuncionarioCollection);
            List<Venda> attachedVendaCollection = new ArrayList<Venda>();
            for (Venda vendaCollectionVendaToAttach : usuario.getVendaCollection()) {
                vendaCollectionVendaToAttach = em.getReference(vendaCollectionVendaToAttach.getClass(), vendaCollectionVendaToAttach.getVendaId());
                attachedVendaCollection.add(vendaCollectionVendaToAttach);
            }
            usuario.setVendaCollection(attachedVendaCollection);
            List<Venda> attachedVendaCollection1 = new ArrayList<Venda>();
            for (Venda vendaCollection1VendaToAttach : usuario.getVendaCollection1()) {
                vendaCollection1VendaToAttach = em.getReference(vendaCollection1VendaToAttach.getClass(), vendaCollection1VendaToAttach.getVendaId());
                attachedVendaCollection1.add(vendaCollection1VendaToAttach);
            }
            usuario.setVendaCollection1(attachedVendaCollection1);
            em.persist(usuario);
            if (empresaId != null) {
                empresaId.getUsuarioCollection().add(usuario);
                empresaId = em.merge(empresaId);
            }
            if (tipoUsuarioId != null) {
                tipoUsuarioId.getUsuarioCollection().add(usuario);
                tipoUsuarioId = em.merge(tipoUsuarioId);
            }
            for (Manutencao manutencaoCollectionManutencao : usuario.getManutencaoCollection()) {
                Usuario oldClienteIdOfManutencaoCollectionManutencao = manutencaoCollectionManutencao.getClienteId();
                manutencaoCollectionManutencao.setClienteId(usuario);
                manutencaoCollectionManutencao = em.merge(manutencaoCollectionManutencao);
                if (oldClienteIdOfManutencaoCollectionManutencao != null) {
                    oldClienteIdOfManutencaoCollectionManutencao.getManutencaoCollection().remove(manutencaoCollectionManutencao);
                    oldClienteIdOfManutencaoCollectionManutencao = em.merge(oldClienteIdOfManutencaoCollectionManutencao);
                }
            }
            for (Compra compraCollectionCompra : usuario.getCompraCollection()) {
                Usuario oldVendedorIdOfCompraCollectionCompra = compraCollectionCompra.getVendedorId();
                compraCollectionCompra.setVendedorId(usuario);
                compraCollectionCompra = em.merge(compraCollectionCompra);
                if (oldVendedorIdOfCompraCollectionCompra != null) {
                    oldVendedorIdOfCompraCollectionCompra.getCompraCollection().remove(compraCollectionCompra);
                    oldVendedorIdOfCompraCollectionCompra = em.merge(oldVendedorIdOfCompraCollectionCompra);
                }
            }
            for (Funcionario funcionarioCollectionFuncionario : usuario.getFuncionarioCollection()) {
                Usuario oldUsuarioIdOfFuncionarioCollectionFuncionario = funcionarioCollectionFuncionario.getUsuarioId();
                funcionarioCollectionFuncionario.setUsuarioId(usuario);
                funcionarioCollectionFuncionario = em.merge(funcionarioCollectionFuncionario);
                if (oldUsuarioIdOfFuncionarioCollectionFuncionario != null) {
                    oldUsuarioIdOfFuncionarioCollectionFuncionario.getFuncionarioCollection().remove(funcionarioCollectionFuncionario);
                    oldUsuarioIdOfFuncionarioCollectionFuncionario = em.merge(oldUsuarioIdOfFuncionarioCollectionFuncionario);
                }
            }
            for (Venda vendaCollectionVenda : usuario.getVendaCollection()) {
                Usuario oldClienteIdOfVendaCollectionVenda = vendaCollectionVenda.getClienteId();
                vendaCollectionVenda.setClienteId(usuario);
                vendaCollectionVenda = em.merge(vendaCollectionVenda);
                if (oldClienteIdOfVendaCollectionVenda != null) {
                    oldClienteIdOfVendaCollectionVenda.getVendaCollection().remove(vendaCollectionVenda);
                    oldClienteIdOfVendaCollectionVenda = em.merge(oldClienteIdOfVendaCollectionVenda);
                }
            }
            for (Venda vendaCollection1Venda : usuario.getVendaCollection1()) {
                Usuario oldTransportadorIdOfVendaCollection1Venda = vendaCollection1Venda.getTransportadorId();
                vendaCollection1Venda.setTransportadorId(usuario);
                vendaCollection1Venda = em.merge(vendaCollection1Venda);
                if (oldTransportadorIdOfVendaCollection1Venda != null) {
                    oldTransportadorIdOfVendaCollection1Venda.getVendaCollection1().remove(vendaCollection1Venda);
                    oldTransportadorIdOfVendaCollection1Venda = em.merge(oldTransportadorIdOfVendaCollection1Venda);
                }
            }
            utx.commit();
        } catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Usuario usuario) throws IllegalOrphanException, NonexistentEntityException, RollbackFailureException, Exception {
        EntityManager em = null;
        try {
            utx.begin();
            em = getEntityManager();
            Usuario persistentUsuario = em.find(Usuario.class, usuario.getUsuarioId());
            Empresa empresaIdOld = persistentUsuario.getEmpresaId();
            Empresa empresaIdNew = usuario.getEmpresaId();
            TipoUsuario tipoUsuarioIdOld = persistentUsuario.getTipoUsuarioId();
            TipoUsuario tipoUsuarioIdNew = usuario.getTipoUsuarioId();
            List<Manutencao> manutencaoCollectionOld = persistentUsuario.getManutencaoCollection();
            List<Manutencao> manutencaoCollectionNew = usuario.getManutencaoCollection();
            List<Compra> compraCollectionOld = persistentUsuario.getCompraCollection();
            List<Compra> compraCollectionNew = usuario.getCompraCollection();
            List<Funcionario> funcionarioCollectionOld = persistentUsuario.getFuncionarioCollection();
            List<Funcionario> funcionarioCollectionNew = usuario.getFuncionarioCollection();
            List<Venda> vendaCollectionOld = persistentUsuario.getVendaCollection();
            List<Venda> vendaCollectionNew = usuario.getVendaCollection();
            List<Venda> vendaCollection1Old = persistentUsuario.getVendaCollection1();
            List<Venda> vendaCollection1New = usuario.getVendaCollection1();
            List<String> illegalOrphanMessages = null;
            for (Manutencao manutencaoCollectionOldManutencao : manutencaoCollectionOld) {
                if (!manutencaoCollectionNew.contains(manutencaoCollectionOldManutencao)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Manutencao " + manutencaoCollectionOldManutencao + " since its clienteId field is not nullable.");
                }
            }
            for (Compra compraCollectionOldCompra : compraCollectionOld) {
                if (!compraCollectionNew.contains(compraCollectionOldCompra)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Compra " + compraCollectionOldCompra + " since its vendedorId field is not nullable.");
                }
            }
            for (Funcionario funcionarioCollectionOldFuncionario : funcionarioCollectionOld) {
                if (!funcionarioCollectionNew.contains(funcionarioCollectionOldFuncionario)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Funcionario " + funcionarioCollectionOldFuncionario + " since its usuarioId field is not nullable.");
                }
            }
            for (Venda vendaCollectionOldVenda : vendaCollectionOld) {
                if (!vendaCollectionNew.contains(vendaCollectionOldVenda)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Venda " + vendaCollectionOldVenda + " since its clienteId field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (empresaIdNew != null) {
                empresaIdNew = em.getReference(empresaIdNew.getClass(), empresaIdNew.getEmpresaId());
                usuario.setEmpresaId(empresaIdNew);
            }
            if (tipoUsuarioIdNew != null) {
                tipoUsuarioIdNew = em.getReference(tipoUsuarioIdNew.getClass(), tipoUsuarioIdNew.getTipoUsuarioId());
                usuario.setTipoUsuarioId(tipoUsuarioIdNew);
            }
            List<Manutencao> attachedManutencaoCollectionNew = new ArrayList<Manutencao>();
            for (Manutencao manutencaoCollectionNewManutencaoToAttach : manutencaoCollectionNew) {
                manutencaoCollectionNewManutencaoToAttach = em.getReference(manutencaoCollectionNewManutencaoToAttach.getClass(), manutencaoCollectionNewManutencaoToAttach.getManutencaoId());
                attachedManutencaoCollectionNew.add(manutencaoCollectionNewManutencaoToAttach);
            }
            manutencaoCollectionNew = attachedManutencaoCollectionNew;
            usuario.setManutencaoCollection(manutencaoCollectionNew);
            List<Compra> attachedCompraCollectionNew = new ArrayList<Compra>();
            for (Compra compraCollectionNewCompraToAttach : compraCollectionNew) {
                compraCollectionNewCompraToAttach = em.getReference(compraCollectionNewCompraToAttach.getClass(), compraCollectionNewCompraToAttach.getCompraId());
                attachedCompraCollectionNew.add(compraCollectionNewCompraToAttach);
            }
            compraCollectionNew = attachedCompraCollectionNew;
            usuario.setCompraCollection(compraCollectionNew);
            List<Funcionario> attachedFuncionarioCollectionNew = new ArrayList<Funcionario>();
            for (Funcionario funcionarioCollectionNewFuncionarioToAttach : funcionarioCollectionNew) {
                funcionarioCollectionNewFuncionarioToAttach = em.getReference(funcionarioCollectionNewFuncionarioToAttach.getClass(), funcionarioCollectionNewFuncionarioToAttach.getFuncionarioId());
                attachedFuncionarioCollectionNew.add(funcionarioCollectionNewFuncionarioToAttach);
            }
            funcionarioCollectionNew = attachedFuncionarioCollectionNew;
            usuario.setFuncionarioCollection(funcionarioCollectionNew);
            List<Venda> attachedVendaCollectionNew = new ArrayList<Venda>();
            for (Venda vendaCollectionNewVendaToAttach : vendaCollectionNew) {
                vendaCollectionNewVendaToAttach = em.getReference(vendaCollectionNewVendaToAttach.getClass(), vendaCollectionNewVendaToAttach.getVendaId());
                attachedVendaCollectionNew.add(vendaCollectionNewVendaToAttach);
            }
            vendaCollectionNew = attachedVendaCollectionNew;
            usuario.setVendaCollection(vendaCollectionNew);
            List<Venda> attachedVendaCollection1New = new ArrayList<Venda>();
            for (Venda vendaCollection1NewVendaToAttach : vendaCollection1New) {
                vendaCollection1NewVendaToAttach = em.getReference(vendaCollection1NewVendaToAttach.getClass(), vendaCollection1NewVendaToAttach.getVendaId());
                attachedVendaCollection1New.add(vendaCollection1NewVendaToAttach);
            }
            vendaCollection1New = attachedVendaCollection1New;
            usuario.setVendaCollection1(vendaCollection1New);
            usuario = em.merge(usuario);
            if (empresaIdOld != null && !empresaIdOld.equals(empresaIdNew)) {
                empresaIdOld.getUsuarioCollection().remove(usuario);
                empresaIdOld = em.merge(empresaIdOld);
            }
            if (empresaIdNew != null && !empresaIdNew.equals(empresaIdOld)) {
                empresaIdNew.getUsuarioCollection().add(usuario);
                empresaIdNew = em.merge(empresaIdNew);
            }
            if (tipoUsuarioIdOld != null && !tipoUsuarioIdOld.equals(tipoUsuarioIdNew)) {
                tipoUsuarioIdOld.getUsuarioCollection().remove(usuario);
                tipoUsuarioIdOld = em.merge(tipoUsuarioIdOld);
            }
            if (tipoUsuarioIdNew != null && !tipoUsuarioIdNew.equals(tipoUsuarioIdOld)) {
                tipoUsuarioIdNew.getUsuarioCollection().add(usuario);
                tipoUsuarioIdNew = em.merge(tipoUsuarioIdNew);
            }
            for (Manutencao manutencaoCollectionNewManutencao : manutencaoCollectionNew) {
                if (!manutencaoCollectionOld.contains(manutencaoCollectionNewManutencao)) {
                    Usuario oldClienteIdOfManutencaoCollectionNewManutencao = manutencaoCollectionNewManutencao.getClienteId();
                    manutencaoCollectionNewManutencao.setClienteId(usuario);
                    manutencaoCollectionNewManutencao = em.merge(manutencaoCollectionNewManutencao);
                    if (oldClienteIdOfManutencaoCollectionNewManutencao != null && !oldClienteIdOfManutencaoCollectionNewManutencao.equals(usuario)) {
                        oldClienteIdOfManutencaoCollectionNewManutencao.getManutencaoCollection().remove(manutencaoCollectionNewManutencao);
                        oldClienteIdOfManutencaoCollectionNewManutencao = em.merge(oldClienteIdOfManutencaoCollectionNewManutencao);
                    }
                }
            }
            for (Compra compraCollectionNewCompra : compraCollectionNew) {
                if (!compraCollectionOld.contains(compraCollectionNewCompra)) {
                    Usuario oldVendedorIdOfCompraCollectionNewCompra = compraCollectionNewCompra.getVendedorId();
                    compraCollectionNewCompra.setVendedorId(usuario);
                    compraCollectionNewCompra = em.merge(compraCollectionNewCompra);
                    if (oldVendedorIdOfCompraCollectionNewCompra != null && !oldVendedorIdOfCompraCollectionNewCompra.equals(usuario)) {
                        oldVendedorIdOfCompraCollectionNewCompra.getCompraCollection().remove(compraCollectionNewCompra);
                        oldVendedorIdOfCompraCollectionNewCompra = em.merge(oldVendedorIdOfCompraCollectionNewCompra);
                    }
                }
            }
            for (Funcionario funcionarioCollectionNewFuncionario : funcionarioCollectionNew) {
                if (!funcionarioCollectionOld.contains(funcionarioCollectionNewFuncionario)) {
                    Usuario oldUsuarioIdOfFuncionarioCollectionNewFuncionario = funcionarioCollectionNewFuncionario.getUsuarioId();
                    funcionarioCollectionNewFuncionario.setUsuarioId(usuario);
                    funcionarioCollectionNewFuncionario = em.merge(funcionarioCollectionNewFuncionario);
                    if (oldUsuarioIdOfFuncionarioCollectionNewFuncionario != null && !oldUsuarioIdOfFuncionarioCollectionNewFuncionario.equals(usuario)) {
                        oldUsuarioIdOfFuncionarioCollectionNewFuncionario.getFuncionarioCollection().remove(funcionarioCollectionNewFuncionario);
                        oldUsuarioIdOfFuncionarioCollectionNewFuncionario = em.merge(oldUsuarioIdOfFuncionarioCollectionNewFuncionario);
                    }
                }
            }
            for (Venda vendaCollectionNewVenda : vendaCollectionNew) {
                if (!vendaCollectionOld.contains(vendaCollectionNewVenda)) {
                    Usuario oldClienteIdOfVendaCollectionNewVenda = vendaCollectionNewVenda.getClienteId();
                    vendaCollectionNewVenda.setClienteId(usuario);
                    vendaCollectionNewVenda = em.merge(vendaCollectionNewVenda);
                    if (oldClienteIdOfVendaCollectionNewVenda != null && !oldClienteIdOfVendaCollectionNewVenda.equals(usuario)) {
                        oldClienteIdOfVendaCollectionNewVenda.getVendaCollection().remove(vendaCollectionNewVenda);
                        oldClienteIdOfVendaCollectionNewVenda = em.merge(oldClienteIdOfVendaCollectionNewVenda);
                    }
                }
            }
            for (Venda vendaCollection1OldVenda : vendaCollection1Old) {
                if (!vendaCollection1New.contains(vendaCollection1OldVenda)) {
                    vendaCollection1OldVenda.setTransportadorId(null);
                    vendaCollection1OldVenda = em.merge(vendaCollection1OldVenda);
                }
            }
            for (Venda vendaCollection1NewVenda : vendaCollection1New) {
                if (!vendaCollection1Old.contains(vendaCollection1NewVenda)) {
                    Usuario oldTransportadorIdOfVendaCollection1NewVenda = vendaCollection1NewVenda.getTransportadorId();
                    vendaCollection1NewVenda.setTransportadorId(usuario);
                    vendaCollection1NewVenda = em.merge(vendaCollection1NewVenda);
                    if (oldTransportadorIdOfVendaCollection1NewVenda != null && !oldTransportadorIdOfVendaCollection1NewVenda.equals(usuario)) {
                        oldTransportadorIdOfVendaCollection1NewVenda.getVendaCollection1().remove(vendaCollection1NewVenda);
                        oldTransportadorIdOfVendaCollection1NewVenda = em.merge(oldTransportadorIdOfVendaCollection1NewVenda);
                    }
                }
            }
            utx.commit();
        } catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
            }
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = usuario.getUsuarioId();
                if (findUsuario(id) == null) {
                    throw new NonexistentEntityException("The usuario with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException, RollbackFailureException, Exception {
        EntityManager em = null;
        try {
            utx.begin();
            em = getEntityManager();
            Usuario usuario;
            try {
                usuario = em.getReference(Usuario.class, id);
                usuario.getUsuarioId();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The usuario with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            List<Manutencao> manutencaoCollectionOrphanCheck = usuario.getManutencaoCollection();
            for (Manutencao manutencaoCollectionOrphanCheckManutencao : manutencaoCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Manutencao " + manutencaoCollectionOrphanCheckManutencao + " in its manutencaoCollection field has a non-nullable clienteId field.");
            }
            List<Compra> compraCollectionOrphanCheck = usuario.getCompraCollection();
            for (Compra compraCollectionOrphanCheckCompra : compraCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Compra " + compraCollectionOrphanCheckCompra + " in its compraCollection field has a non-nullable vendedorId field.");
            }
            List<Funcionario> funcionarioCollectionOrphanCheck = usuario.getFuncionarioCollection();
            for (Funcionario funcionarioCollectionOrphanCheckFuncionario : funcionarioCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Funcionario " + funcionarioCollectionOrphanCheckFuncionario + " in its funcionarioCollection field has a non-nullable usuarioId field.");
            }
            List<Venda> vendaCollectionOrphanCheck = usuario.getVendaCollection();
            for (Venda vendaCollectionOrphanCheckVenda : vendaCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Venda " + vendaCollectionOrphanCheckVenda + " in its vendaCollection field has a non-nullable clienteId field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Empresa empresaId = usuario.getEmpresaId();
            if (empresaId != null) {
                empresaId.getUsuarioCollection().remove(usuario);
                empresaId = em.merge(empresaId);
            }
            TipoUsuario tipoUsuarioId = usuario.getTipoUsuarioId();
            if (tipoUsuarioId != null) {
                tipoUsuarioId.getUsuarioCollection().remove(usuario);
                tipoUsuarioId = em.merge(tipoUsuarioId);
            }
            List<Venda> vendaCollection1 = usuario.getVendaCollection1();
            for (Venda vendaCollection1Venda : vendaCollection1) {
                vendaCollection1Venda.setTransportadorId(null);
                vendaCollection1Venda = em.merge(vendaCollection1Venda);
            }
            em.remove(usuario);
            utx.commit();
        } catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Usuario> findUsuarioEntities() {
        return findUsuarioEntities(true, -1, -1);
    }

    public List<Usuario> findUsuarioEntities(int maxResults, int firstResult) {
        return findUsuarioEntities(false, maxResults, firstResult);
    }

    private List<Usuario> findUsuarioEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Usuario as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Usuario findUsuario(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Usuario.class, id);
        } finally {
            em.close();
        }
    }

    public Usuario findUsuarioByEmailAndPwd(String email, String pwd) {
       EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("SELECT t FROM Usuario t WHERE t.email = '" + email + "' AND t.senha = '" +pwd+ "'");
            List<Usuario> list = q.getResultList();
            if (list.size() >= 1) {
                return list.get(0);
            } else {
                return null;
            }
        } finally {
            em.close();
        }
    }

    public Boolean emailExist(String email){

        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("SELECT t FROM Usuario t WHERE t.email = '" + email + "'");
            List<Usuario> list = q.getResultList();
            if (list.size() >= 1) {
                return true;
            } else {
                return false;
            }
        } finally {
            em.close();
        }
    }

    public int getUsuarioCount() {
        EntityManager em = getEntityManager();
        try {
            return ((Long) em.createQuery("select count(o) from Usuario as o").getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
